#include "TDADocumentos.h"

int fCreateLexico(void *pItem)
{
	return EXIT_SUCCESS;
}


int fCopyLexico(void *pTo,void *pFrom)
{
	strcpy((char*)pTo,(char*) pFrom);

	return EXIT_SUCCESS;
}

int fCmpLexico(void *pTo,void *pFrom)
{
	return strcmp((char*)pTo,(char*) pFrom);
}

int fOrderLexico(void *pTo,void *pFrom)
{
	return strcmp((char*)pTo,(char*) pFrom);
}


int fDestroyLexico(void *pItem)
{
	return EXIT_SUCCESS;
}

int fCopyDocumento(void *pTo,void *pFrom)
{
	ITEM_TDA_DOCUMENTOS *to = (ITEM_TDA_DOCUMENTOS*)pTo;
	ITEM_TDA_DOCUMENTOS *from = (ITEM_TDA_DOCUMENTOS*)pFrom;

	tda_docuemntos_crear_documento(to);

	to->cantidadConsultas = from->cantidadConsultas;
	to->idDocumento = from->idDocumento;
	strcpy(to->titulo,from->titulo);

	fCopyListaOrdenada(to->listaLexicos,from->listaLexicos);

	return EXIT_SUCCESS;
}

int fDestroyDocumento(void *pItem)
{
	ITEM_TDA_DOCUMENTOS *item = (ITEM_TDA_DOCUMENTOS*)pItem;

	item->cantidadConsultas = 0;
	item->idDocumento = 0;
	LSO_Vaciar(item->listaLexicos);
	free(item->listaLexicos);
	item->listaLexicos = NULL;

	strcpy(item->titulo,"");

	return EXIT_SUCCESS;
}

int fCmpDocumento(void *pTo,void *pFrom)
{
	ITEM_TDA_DOCUMENTOS *to = (ITEM_TDA_DOCUMENTOS*)pTo;
	ITEM_TDA_DOCUMENTOS *from = (ITEM_TDA_DOCUMENTOS*)pFrom;

	int cmp = 0;

	if (to->idDocumento > from->idDocumento)
		cmp = 1;

	if (to->idDocumento < from->idDocumento)
		cmp = -1;

	return cmp;
}

int fOrderDocumento(void *pTo,void *pFrom)
{
	ITEM_TDA_DOCUMENTOS *to = (ITEM_TDA_DOCUMENTOS*)pTo;
	ITEM_TDA_DOCUMENTOS *from = (ITEM_TDA_DOCUMENTOS*)pFrom;

	int cmp = 0;

	if (to->idDocumento > from->idDocumento)
		cmp = 1;

	if (to->idDocumento < from->idDocumento)
		cmp = -1;

	return cmp;
}


int fCreateDocumento(void *pItem)
{
	ITEM_TDA_DOCUMENTOS *item = (ITEM_TDA_DOCUMENTOS *)pItem;
	return tda_docuemntos_crear_documento(item);
}

int tda_docuemntos_crear(TDA_DOCUMENTOS *tdaDocumentos)
{
	tdaDocumentos->listaDocumentos = malloc(sizeof(TListaSimpleOrdenada));

	LSO_Crear(tdaDocumentos->listaDocumentos, sizeof(ITEM_TDA_DOCUMENTOS),fCreateDocumento,fCmpDocumento,fCopyDocumento,fDestroyDocumento,fOrderDocumento);
}

int tda_docuemntos_crear_documento(ITEM_TDA_DOCUMENTOS *documento)
{
	documento->listaLexicos = malloc(sizeof(TListaSimpleOrdenada));

	LSO_Crear(documento->listaLexicos, MAX_LENGTH_LEXICO,fCreateLexico,fCmpLexico,fCopyLexico,fDestroyLexico,fOrderLexico);
}


int tda_docuemntos_destruir(TDA_DOCUMENTOS *tdaDocumentos)
{
	free(tdaDocumentos->listaDocumentos);
}

int tda_docuemntos_alta(TDA_DOCUMENTOS *tdaDocumentos,ITEM_TDA_DOCUMENTOS *documento)
{
	LSO_AgregarElemento(tdaDocumentos->listaDocumentos,documento);
}

int tda_docuemntos_baja(TDA_DOCUMENTOS *tdaDocumentos,ITEM_TDA_DOCUMENTOS *documento)
{
	LSO_EliminarElemento(tdaDocumentos->listaDocumentos,documento);
}

int tda_docuemntos_modificacion(TDA_DOCUMENTOS *tdaDocumentos,ITEM_TDA_DOCUMENTOS *documento)
{
	LSO_ModificarElemento(tdaDocumentos->listaDocumentos,documento);

}
int tda_docuemntos_consulta(TDA_DOCUMENTOS *tdaDocumentos,ITEM_TDA_DOCUMENTOS *documento)
{
	LSO_ConsultarElemento(tdaDocumentos->listaDocumentos,documento);
}

int tda_docuemntos_agregar_lexico(ITEM_TDA_DOCUMENTOS *documento,char *lexico)
{
	LSO_AgregarElemento(documento->listaLexicos,lexico);
}

int tda_docuemntos_eliminar_lexico(ITEM_TDA_DOCUMENTOS *documento,char *lexico)
{
	LSO_EliminarElemento(documento->listaLexicos,lexico);
}


int tda_docuemntos_incrementarConsultas(TDA_DOCUMENTOS *tdaDocumentos,int idDocumento)
{
	ITEM_TDA_DOCUMENTOS *itemDocumento;
	itemDocumento = malloc(sizeof(ITEM_TDA_DOCUMENTOS));
	fCreateDocumento(itemDocumento);

	itemDocumento->idDocumento = idDocumento;

	if (tda_lexico_consultar(tdaDocumentos, itemDocumento))
	{
		itemDocumento->cantidadConsultas = itemDocumento->cantidadConsultas + 1;
		tda_docuemntos_modificacion(tdaDocumentos, itemDocumento);
	}

	fDestroyDocumento(itemDocumento);
	free(itemDocumento);
	return EXIT_SUCCESS;
}


int tda_docuemntos_printf(TDA_DOCUMENTOS *tdaDocumentos)
{
	return tda_docuemntos_print_listaDocumentos(tdaDocumentos->listaDocumentos);
}

int tda_docuemntos_print_listaDocumentos(TListaSimpleOrdenada *listaDocumentos)
{
	ITEM_TDA_DOCUMENTOS item;
	int i = 0;

	if (!LSO_Vacia(*(listaDocumentos)))
	{
		LSO_Mover_Cte(listaDocumentos,LSO_Primero);

		do
		{
			LSO_Elem_Cte(*(listaDocumentos),&item);

			char *listaLexicos = malloc(MAX_CANT_LEXICOS_POR_DOCUMENTO * MAX_LENGTH_LEXICO);

			if (!LSO_Vacia(*(item.listaLexicos)))
			{
				LSO_Mover_Cte(item.listaLexicos,LSO_Primero);
				char lexico[MAX_LENGTH_LEXICO];
				LSO_Elem_Cte(*(item.listaLexicos),&lexico);
				strcpy (listaLexicos,lexico);
				while(LSO_Mover_Cte(item.listaLexicos,LSO_Siguiente))
				{
					strcat (listaLexicos,",");
					LSO_Elem_Cte(*(item.listaLexicos),&lexico);
					strcat (listaLexicos,lexico);
				}
			}


			printf("id: %d, titulo: %s,cant: %d,[%s]\n",
											item.idDocumento,
											item.titulo,
											item.cantidadConsultas,
											listaLexicos);
			fflush(stdout);

			free(listaLexicos);


		}
		while(LSO_Mover_Cte(listaDocumentos,LSO_Siguiente));

	}

}

int tda_docuemntos_alta_desde_disco(TDA_DOCUMENTOS *tdaDocumentos,int idDocumento,char *fileName)
{
	FILE *fp;
	ITEM_TDA_DOCUMENTOS documento;
	fp = fopen(fileName, "r"); // read mode
	if (fp == NULL) {
		perror("Error while opening the file.\n");
		exit(EXIT_FAILURE);
	}
	char str1[3000];
	tda_docuemntos_crear_documento(&documento);
	documento.idDocumento = idDocumento;
	strcpy(documento.titulo,fileName);
	int indiceLexico = 0;
	while (fscanf(fp, "%s", str1) > 0) {
		char *chInput;
		chInput = strtok(str1, " .");
		while (chInput!= NULL)
		{
			tda_docuemntos_agregar_lexico(&documento,chInput);
			chInput = strtok(NULL, " .");
			indiceLexico++;
		}
	}
	documento.cantidadConsultas = 0;
	tda_docuemntos_alta(tdaDocumentos, &documento);
	fclose(fp);
	return EXIT_SUCCESS;
}

/* PRE:  fp open
   POST: tdaDocumentos cargado con los datos del archivo
 */
int tda_documentos_read_file(TDA_DOCUMENTOS *tdaDocumentos,FILE *fp)
{

	char str1[2000];

	//VA_create(array, sizeof(int)*10);

	while (fscanf(fp, "%s", str1) > 0) {


		char *chInput;

		int indiceInput = 0;


		char listaLexicos[800];
		char camposDocumento[800];




		chInput = strtok(str1, "[]");

		while (chInput!= NULL)
		{
			if (indiceInput == 0)
			{
				strcpy(camposDocumento, chInput);
			}

			if (indiceInput == 1) {

				strcpy(listaLexicos, chInput);
			}

			chInput = strtok(NULL, "[]");
			indiceInput++;
		}




		ITEM_TDA_DOCUMENTOS *itemDocumento;
		itemDocumento = malloc(sizeof(ITEM_TDA_DOCUMENTOS));
		tda_docuemntos_crear_documento(itemDocumento);

		char *ch;
		int indice = 0;

		ch = strtok(camposDocumento, ",");


		while (ch != NULL) {

			//idDocumento,titulo,cantidadConsultasDocumento,[lexico1,lexico2,..,lexicoN]

			if (indice == 0)
			{
				itemDocumento->idDocumento = atoi(ch);
			}

			if (indice == 1) {

				strcpy(itemDocumento->titulo, ch);

			}
			if (indice == 2) {
				itemDocumento->cantidadConsultas = atoi(ch);
			}


			ch = strtok(NULL, ",");
			indice++;
		}


		char *chLexico;
		int indiceLexico = 0;


		chLexico = strtok(listaLexicos, ",");
		while (chLexico != NULL)
		{
			tda_docuemntos_agregar_lexico(itemDocumento,chLexico);

			chLexico = strtok(NULL, ",");

			indiceLexico++;

		}


		tda_docuemntos_alta(tdaDocumentos, itemDocumento);

		free(itemDocumento);

	}

	return EXIT_SUCCESS;
}

/* PRE:  fp open
 	 	 tdaDocumentos cargado
   POST: guarda los datos de tdaDocumentos en el archivo apuntado por fp
 */
int tda_documentos_write_file(TDA_DOCUMENTOS *tdaDocumentos,FILE *fp)
{
	ITEM_TDA_DOCUMENTOS itemDocumento;
	int i = 0;

	if (!LSO_Vacia(*(tdaDocumentos->listaDocumentos))) {
		LSO_Mover_Cte(tdaDocumentos->listaDocumentos, LSO_Primero);

		do {
			//itemLexico = malloc(sizeof(ITEM_LEXICO));

			LSO_Elem_Cte(*(tdaDocumentos->listaDocumentos), &itemDocumento);


			//idDocumento,titulo,cantidadConsultasDocumento,[lexico1,lexico2,..,lexicoN]

			char idDocumento[8];
			sprintf(idDocumento, "%d", itemDocumento.idDocumento);

			char cantidadConsultas[8];
			sprintf(cantidadConsultas, "%d", itemDocumento.cantidadConsultas);

			fprintf(fp, idDocumento);
			fprintf(fp, ",");
			fprintf(fp, itemDocumento.titulo);
			fprintf(fp, ",");
			fprintf(fp, cantidadConsultas);
			fprintf(fp, ",");
			fprintf(fp, "[");

			if (!LSO_Vacia(*(itemDocumento.listaLexicos)))
			{
				LSO_Mover_Cte(itemDocumento.listaLexicos,LSO_Primero);
				char lexico[MAX_LENGTH_LEXICO];
				LSO_Elem_Cte(*(itemDocumento.listaLexicos),&lexico);
				fprintf(fp, lexico);
				while(LSO_Mover_Cte(itemDocumento.listaLexicos,LSO_Siguiente))
				{
					fprintf(fp, ",");
					LSO_Elem_Cte(*(itemDocumento.listaLexicos),&lexico);
					fprintf(fp, lexico);
				}
			}

			fprintf(fp, "]");
			fprintf(fp, "\n");



			//printf("%s : %i",itemLexico.lexico,itemLexico.cantidadConsultasLexico);
		} while (LSO_Mover_Cte(tdaDocumentos->listaDocumentos, LSO_Siguiente));

	}

	return EXIT_SUCCESS;
}


int tda_docuemntos_vacio(TDA_DOCUMENTOS *tdaDocumentos)
{
	return LSO_Vacia(*(tdaDocumentos->listaDocumentos));
}
